package 蚂蚁课堂;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.stream.IntStream;

/**
 * 发布与订阅模式：
 */
public class ArrayBlockingQueueDemo2 {

    /**
     * 初始化ArrayBlockingQueue阻塞队列，并设置10个空间
     */
    private ArrayBlockingQueue<Integer> arrayBlockingQueue=new ArrayBlockingQueue<>(10);

    /**
     * 静态代码块：
     *
     *       static{}
     *
     *       执行优先级高于非静态的初始化块，它会在类初始化（类初始化这个问题改天再详细讨论）的时候执行一次，执行完成便销毁，它仅能初始化类变量，即static修饰的数据成员。
     *
     * 非静态代码块：
     *
     *       {}
     *
     *       执行的时候如果有静态初始化块，先执行静态初始化块再执行非静态初始化块，在每个对象生成时都会被执行一次，它可以初始化类的实例变量。非静态初始化块会在构造函数执行时，在构造函数主体代码执行之前被运行。
     */
     {
        customer();
    }

    /**
     * 消费者
     */
    public  void customer(){
        new Thread(new Runnable(){
            @Override
            public void run() {
                while (true){
                    try {
                        //从队列中取消息，若队列为空则阻塞
                        Integer take = arrayBlockingQueue.take();
                        System.out.println("消费数据："+take);
                        TimeUnit.SECONDS.sleep(2);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }

    public void publics(){
        IntStream.of(1,2,3,4,5,6,7,8,9,0,11).forEach(x-> {
            try {
                //向队列中存消息，若队列满了，则阻塞
                arrayBlockingQueue.put(x);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
    }

    public static void main(String[] args) {
        ArrayBlockingQueueDemo2 arrayBlockingQueueDemo2=new ArrayBlockingQueueDemo2();
        arrayBlockingQueueDemo2.publics();
    }

}
